
/**
 * Javascript 面向对象支持，样例如下：<br>
 * 
 */
;(function(window, undefined){
	var Class = window.Class,
	//探测函数内是否含有this._super.*的引用，如果有则重写调用函数，以支持对父类的调用
	fnTest = /xyz/.test(function(){xyz;}) ? /\b_super.\b/ : /.*/;
	
	try{
		//检查Class是否已经存在
		if(typeof Class === "undefined"){
			/**
			 * @param prototype 父类原型实例
			 * @param option 子类定义
			 * @param 
			 */
			var extend = function(prototype, option, revert){
				//保存父类function接口，以供子类使用this._super调用
				var _super = {};
				
				//保存父类function
				for(var name in this.prototype){
					copy = this.prototype[ name ];
					if ( copy !== undefined && (typeof copy == "function" && name != "constructor")) {
						_super[ name ] =  copy;
					}
				}
				
				//覆盖父类属性和方法
				for(var name in option){
					var copy = option[ name ];
					
					if ( copy !== undefined ) {//忽略未赋值属性
						//如果revert = true，则保留父类属性
						if(revert && prototype[ name ]){
							continue;
						}
						/**
						 * 1. 如果子类属性为函数，且父类包含的该属性也为函数，同时如果子类函数包含了_super单词，
						 * 	则对该函数进行重写，支持this._super.*调用；<br>
						 * 2. 如果第1条不满足，直接覆盖父类属性
						 */
						prototype[ name ] = typeof copy == "function" &&
				        	typeof _super[name] == "function" && fnTest.test(copy) ?
				                (function(name, fn){
				                  return function() {
				                	/**
				                	 * 以下代码对this._super.*调用进行优化，支持多级继承:
				                	 * <ul>
				                	 * 	<li>this._super执行一组被重新的函数，这组函数对闭包可见的_super函数进行了重写。</li>
				                	 * 	<li>this._super.__super指向闭包的_super，以供判断当前this._super是否和同级父类匹配</li>
				                	 * 	<li>this.__supers为数组，包含所有父类的被重写函数</li>
				                	 * </ul>
				                	 */
				                    if(this._super === undefined || this._super.__super !== _super){//判断当前this._super是否为该父类函数
				                    	var __super = false;
				                    	if(this.__supers === undefined)
				                    		this.__supers = [];//保存所有被重写的父类函数
				                    	//查找该级父类函数是否已经被重写过，如果已经被重写，则直接使用
				                    	for(var i=0; i < this.__supers.length; i++){
			                    			if(this.__supers[i].__super === _super){
			                    				//found
			                    				__super = this.__supers[i];
			                    			}
			                    		}
				                    	if(__super === false){
				                    		//该级父类函数未被重写，执行重写操作
				                    		__super = {};
			                    			__super.__super = _super;
			                    			for(var name in _super){
			                    				__super[name] = (function(context, fn){
			                    					return function(){
			                    						var ret = fn.apply(context, arguments);
			                    						return ret;
			                    					};
			                    				})(this, _super[name]);
			                    			}
			                    		}
				                    	//保存父类重写函数以供下次使用（优化操作）
				                    	this.__supers.push(__super);
				                    	//确保使用该级父类重写函数
				                    	this._super = __super;
				                    }
				                   
				                    //实际调用函数
				                    var ret = fn.apply(this, arguments);       
				                   
				                    return ret;
				                  };
				                })(name, copy) : copy;
					}
				}
				return prototype;
			};
			
			var Class = function(){
			};
			/**
			 * var Person = Class.extend({
			 * 	init: function(){
			 * 	},
			 * 	smile: function(){
			 * 		alert("Person smile");
			 * 	}
			 * });
			 * 
			 * var Peter = Person.extend({
			 * 	init: function(){
			 * 	},
			 * 	smile: function(){
			 * 		this._super.smile();
			 * 		alert("Peter smile");
			 * 	}
			 * });
			 * 
			 */
			Class.extend = function(option){
				option = option || {};
				//option.init = option.init || function(){};
				
				/**
				 * 临时类，主要用于继承父类
				 * 
				 * @ignore 
				 */
				var tempClass = function(){};
				//扩展父类属性
				tempClass.prototype = this.prototype;
				
				/**
				 * 创建prototype实体，
				 * 
				 * @ignore
				 */
				var prototype = new tempClass();
				
				//子类属性扩展/覆盖
				prototype = extend.apply(this, [prototype, option]);
				
				var subClass = function(){
					if(this.init){
						this.init.apply(this, arguments);
					}
				};
				
				//继承父类原型
				subClass.prototype = prototype;
				//重新指定构造函数，确保this.init方法被调用，类的真正初始化操作可以在this.init()方法实现
				subClass.prototype.constructor = subClass;
				//保证每个子类都含有extend方法
				subClass.extend = arguments.callee;
				return subClass;
			};
		}
		window.Class = Class;
	}catch(e){
		
	}
	
})(window);